window._classCallCheck2 = _classCallCheck;
window._createClass2 = _createClass;
window._get2 = _get;
window._getPrototypeOf2 = _getPrototypeOf;
window._inherits2 = _inherits;
window._createSuper2 = _createSuper;
window._slicedToArray2 = _slicedToArray;
window._createForOfIteratorHelper2 = _createForOfIteratorHelper;
window._asyncToGenerator2 = _asyncToGenerator;
window._defineProperty2 = _defineProperty;
window._regeneratorRuntime2 = regeneratorRuntime;
window.regenerator = regeneratorRuntime();
window._toConsumableArray2 = _toConsumableArray;
var arrayWithoutHoles = _arrayWithoutHoles,
    iterableToArray = _iterableToArray,
    nonIterableSpread = _nonIterableSpread;
window._wrapNativeSuper2 = _wrapNativeSuper;
var isNativeFunction = function _isNativeFunction(n) {
    return -1 !== Function.toString.call(n).indexOf("[native code]");
};
var construct = _construct;

function _construct(t, e, r) {
    return (
        isNativeReflectConstruct() ?
        (_construct = Reflect.construct.bind()) :
        (_construct = function(t, e, r) {
            var o = [null];
            o.push.apply(o, e);
            var c = new(Function.bind.apply(t, o))();
            return r && setPrototypeOf(c, r.prototype), c;
        }),
        _construct.apply(null, arguments)
    );
}

function _wrapNativeSuper(t) {
    var e = "function" == typeof Map ? new Map() : void 0;
    return (
        (_wrapNativeSuper = function(t) {
            if (null === t || !isNativeFunction(t)) return t;
            if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
            if (void 0 !== e) {
                if (e.has(t)) return e.get(t);
                e.set(t, r);
            }

            function r() {
                return construct(t, arguments, getPrototypeOf(this).constructor);
            }
            return (
                (r.prototype = Object.create(t.prototype, {
                    constructor: {
                        value: r,
                        enumerable: !1,
                        writable: !0,
                        configurable: !0
                    }
                })),
                setPrototypeOf(r, t)
            );
        }),
        _wrapNativeSuper(t)
    );
}

function _nonIterableSpread() {
    throw new TypeError(
        "Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
    );
}

function _iterableToArray(r) {
    if (("undefined" != typeof Symbol && null != r[Symbol.iterator]) || null != r["@@iterator"]) return Array.from(r);
}

function _arrayWithoutHoles(r) {
    if (Array.isArray(r)) return arrayLikeToArray(r);
}

function _toConsumableArray(r) {
    return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();
}
var superPropBase = _superPropBase;
var setPrototypeOf = _setPrototypeOf;
var getPrototypeOf = _getPrototypeOf,
    isNativeReflectConstruct = _isNativeReflectConstruct,
    possibleConstructorReturn = _possibleConstructorReturn;
var arrayWithHoles = _arrayWithHoles,
    iterableToArrayLimit = _iterableToArrayLimit,
    unsupportedIterableToArray = _unsupportedIterableToArray,
    nonIterableRest = _nonIterableRest;
var toPropertyKey = _toPropertyKey;
var assertThisInitialized = _assertThisInitialized;
var arrayLikeToArray = _arrayLikeToArray;

function _arrayLikeToArray(r, a) {
    (null == a || a > r.length) && (a = r.length);
    for (var e = 0, n = new Array(a); e < a; e++) n[e] = r[e];
    return n;
}

function _assertThisInitialized(e) {
    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    return e;
}

function _nonIterableRest() {
    throw new TypeError(
        "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
    );
}

function _unsupportedIterableToArray(r, e) {
    if (r) {
        if ("string" == typeof r) return arrayLikeToArray(r, e);
        var t = Object.prototype.toString.call(r).slice(8, -1);
        return (
            "Object" === t && r.constructor && (t = r.constructor.name),
            "Map" === t || "Set" === t ?
            Array.from(r) :
            "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ?
            arrayLikeToArray(r, e) :
            void 0
        );
    }
}

function _iterableToArrayLimit(r, e) {
    var l = null == r ? null : ("undefined" != typeof Symbol && r[Symbol.iterator]) || r["@@iterator"];
    if (null != l) {
        var t,
            n,
            i,
            a,
            u = [],
            o = !0,
            f = !1;
        try {
            if (((i = (l = l.call(r)).next), 0 === e)) {
                if (Object(l) !== l) return;
                o = !1;
            } else
                for (; !(o = (t = i.call(l)).done) && (u.push(t.value), u.length !== e); o = !0);
        } catch (r) {
            (f = !0), (n = r);
        } finally {
            try {
                if (!o && null != l.return && ((a = l.return()), Object(a) !== a)) return;
            } finally {
                if (f) throw n;
            }
        }
        return u;
    }
}

function _arrayWithHoles(r) {
    if (Array.isArray(r)) return r;
}

function _possibleConstructorReturn(e, r) {
    if (r && ("object" === typeof r || "function" == typeof r)) return r;
    if (void 0 !== r) throw new TypeError("Derived constructors may only return object or undefined");
    return assertThisInitialized(e);
}

function _isNativeReflectConstruct() {
    if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
    if (Reflect.construct.sham) return !1;
    if ("function" == typeof Proxy) return !0;
    try {
        return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})), !0;
    } catch (t) {
        return !1;
    }
}

function _setPrototypeOf(t, e) {
    return Object.setPrototypeOf(t, e);
}

function _superPropBase(e, r) {
    for (; !Object.prototype.hasOwnProperty.call(e, r) && null !== (e = getPrototypeOf(e)););
    return e;
}

function regeneratorRuntime() {
    "use strict";

    /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
    regeneratorRuntime = function() {
        return t;
    };
    var t = {},
        r = Object.prototype,
        e = r.hasOwnProperty,
        n =
        Object.defineProperty ||
        function(t, r, e) {
            t[r] = e.value;
        },
        o = "function" == typeof Symbol ? Symbol : {},
        i = o.iterator || "@@iterator",
        a = o.asyncIterator || "@@asyncIterator",
        c = o.toStringTag || "@@toStringTag";

    function u(t, r, e) {
        return (
            Object.defineProperty(t, r, {
                value: e,
                enumerable: !0,
                configurable: !0,
                writable: !0
            }),
            t[r]
        );
    }
    try {
        u({}, "");
    } catch (t) {
        u = function(t, r, e) {
            return (t[r] = e);
        };
    }

    function h(t, r, e, o) {
        var i = r && r.prototype instanceof s ? r : s,
            a = Object.create(i.prototype),
            c = new O(o || []);
        return (
            n(a, "_invoke", {
                value: L(t, e, c)
            }),
            a
        );
    }

    function l(t, r, e) {
        try {
            return {
                type: "normal",
                arg: t.call(r, e)
            };
        } catch (t) {
            return {
                type: "throw",
                arg: t
            };
        }
    }
    t.wrap = h;
    var f = {};

    function s() {}

    function p() {}

    function v() {}
    var y = {};
    u(y, i, function() {
        return this;
    });
    var d = Object.getPrototypeOf,
        g = d && d(d(j([])));
    g && g !== r && e.call(g, i) && (y = g);
    var m = (v.prototype = s.prototype = Object.create(y));

    function w(t) {
        ["next", "throw", "return"].forEach(function(r) {
            u(t, r, function(t) {
                return this._invoke(r, t);
            });
        });
    }

    function x(t, r) {
        var o;
        n(this, "_invoke", {
            value: function(n, i) {
                function a() {
                    return new r(function(o, a) {
                        !(function n(o, i, a, c) {
                            var u = l(t[o], t, i);
                            if ("throw" !== u.type) {
                                var h = u.arg,
                                    f = h.value;
                                return f && "object" == typeof f && e.call(f, "__await") ?
                                    r.resolve(f.__await).then(
                                        function(t) {
                                            n("next", t, a, c);
                                        },
                                        function(t) {
                                            n("throw", t, a, c);
                                        }
                                    ) :
                                    r.resolve(f).then(
                                        function(t) {
                                            (h.value = t), a(h);
                                        },
                                        function(t) {
                                            return n("throw", t, a, c);
                                        }
                                    );
                            }
                            c(u.arg);
                        })(n, i, o, a);
                    });
                }
                return (o = o ? o.then(a, a) : a());
            }
        });
    }

    function L(t, r, e) {
        var n = "suspendedStart";
        return function(o, i) {
            if ("executing" === n) throw new Error("Generator is already running");
            if ("completed" === n) {
                if ("throw" === o) throw i;
                return {
                    value: void 0,
                    done: !0
                };
            }
            for (e.method = o, e.arg = i;;) {
                var a = e.delegate;
                if (a) {
                    var c = b(a, e);
                    if (c) {
                        if (c === f) continue;
                        return c;
                    }
                }
                if ("next" === e.method) e.sent = e._sent = e.arg;
                else if ("throw" === e.method) {
                    if ("suspendedStart" === n) throw ((n = "completed"), e.arg);
                    e.dispatchException(e.arg);
                } else "return" === e.method && e.abrupt("return", e.arg);
                n = "executing";
                var u = l(t, r, e);
                if ("normal" === u.type) {
                    if (((n = e.done ? "completed" : "suspendedYield"), u.arg === f)) continue;
                    return {
                        value: u.arg,
                        done: e.done
                    };
                }
                "throw" === u.type && ((n = "completed"), (e.method = "throw"), (e.arg = u.arg));
            }
        };
    }

    function b(t, r) {
        var e = r.method,
            n = t.iterator[e];
        if (void 0 === n)
            return (
                (r.delegate = null),
                ("throw" === e &&
                    t.iterator.return &&
                    ((r.method = "return"), (r.arg = void 0), b(t, r), "throw" === r.method)) ||
                ("return" !== e &&
                    ((r.method = "throw"),
                        (r.arg = new TypeError("The iterator does not provide a '" + e + "' method")))),
                f
            );
        var o = l(n, t.iterator, r.arg);
        if ("throw" === o.type) return (r.method = "throw"), (r.arg = o.arg), (r.delegate = null), f;
        var i = o.arg;
        return i ?
            i.done ?
            ((r[t.resultName] = i.value),
                (r.next = t.nextLoc),
                "return" !== r.method && ((r.method = "next"), (r.arg = void 0)),
                (r.delegate = null),
                f) :
            i :
            ((r.method = "throw"),
                (r.arg = new TypeError("iterator result is not an object")),
                (r.delegate = null),
                f);
    }

    function E(t) {
        var r = {
            tryLoc: t[0]
        };
        1 in t && (r.catchLoc = t[1]), 2 in t && ((r.finallyLoc = t[2]), (r.afterLoc = t[3])), this.tryEntries.push(r);
    }

    function _(t) {
        var r = t.completion || {};
        (r.type = "normal"), delete r.arg, (t.completion = r);
    }

    function O(t) {
        (this.tryEntries = [{
            tryLoc: "root"
        }]),
        t.forEach(E, this),
            this.reset(!0);
    }

    function j(t) {
        if (t) {
            var r = t[i];
            if (r) return r.call(t);
            if ("function" == typeof t.next) return t;
            if (!isNaN(t.length)) {
                var n = -1,
                    o = function r() {
                        for (; ++n < t.length;)
                            if (e.call(t, n)) return (r.value = t[n]), (r.done = !1), r;
                        return (r.value = void 0), (r.done = !0), r;
                    };
                return (o.next = o);
            }
        }
        return {
            next: k
        };
    }

    function k() {
        return {
            value: void 0,
            done: !0
        };
    }
    return (
        (p.prototype = v),
        n(m, "constructor", {
            value: v,
            configurable: !0
        }),
        n(v, "constructor", {
            value: p,
            configurable: !0
        }),
        (p.displayName = u(v, c, "GeneratorFunction")),
        (t.isGeneratorFunction = function(t) {
            var r = "function" == typeof t && t.constructor;
            return !!r && (r === p || "GeneratorFunction" === (r.displayName || r.name));
        }),
        (t.mark = function(t) {
            return (
                Object.setPrototypeOf ? Object.setPrototypeOf(t, v) : ((t.__proto__ = v), u(t, c, "GeneratorFunction")),
                (t.prototype = Object.create(m)),
                t
            );
        }),
        (t.awrap = function(t) {
            return {
                __await: t
            };
        }),
        w(x.prototype),
        u(x.prototype, a, function() {
            return this;
        }),
        (t.AsyncIterator = x),
        (t.async = function(r, e, n, o, i) {
            void 0 === i && (i = Promise);
            var a = new x(h(r, e, n, o), i);
            return t.isGeneratorFunction(e) ?
                a :
                a.next().then(function(t) {
                    return t.done ? t.value : a.next();
                });
        }),
        w(m),
        u(m, c, "Generator"),
        u(m, i, function() {
            return this;
        }),
        u(m, "toString", function() {
            return "[object Generator]";
        }),
        (t.keys = function(t) {
            var r = Object(t),
                e = [];
            for (var n in r) e.push(n);
            return (
                e.reverse(),
                function t() {
                    for (; e.length;) {
                        var n = e.pop();
                        if (n in r) return (t.value = n), (t.done = !1), t;
                    }
                    return (t.done = !0), t;
                }
            );
        }),
        (t.values = j),
        (O.prototype = {
            constructor: O,
            reset: function(t) {
                if (
                    ((this.prev = 0),
                        (this.next = 0),
                        (this.sent = this._sent = void 0),
                        (this.done = !1),
                        (this.delegate = null),
                        (this.method = "next"),
                        (this.arg = void 0),
                        this.tryEntries.forEach(_), !t)
                )
                    for (var r in this)
                        "t" === r.charAt(0) && e.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = void 0);
            },
            stop: function() {
                this.done = !0;
                var t = this.tryEntries[0].completion;
                if ("throw" === t.type) throw t.arg;
                return this.rval;
            },
            dispatchException: function(t) {
                if (this.done) throw t;
                var r = this;

                function n(e, n) {
                    return (
                        (a.type = "throw"), (a.arg = t), (r.next = e), n && ((r.method = "next"), (r.arg = void 0)), !!n
                    );
                }
                for (var o = this.tryEntries.length - 1; o >= 0; --o) {
                    var i = this.tryEntries[o],
                        a = i.completion;
                    if ("root" === i.tryLoc) return n("end");
                    if (i.tryLoc <= this.prev) {
                        var c = e.call(i, "catchLoc"),
                            u = e.call(i, "finallyLoc");
                        if (c && u) {
                            if (this.prev < i.catchLoc) return n(i.catchLoc, !0);
                            if (this.prev < i.finallyLoc) return n(i.finallyLoc);
                        } else if (c) {
                            if (this.prev < i.catchLoc) return n(i.catchLoc, !0);
                        } else {
                            if (!u) throw new Error("try statement without catch or finally");
                            if (this.prev < i.finallyLoc) return n(i.finallyLoc);
                        }
                    }
                }
            },
            abrupt: function(t, r) {
                for (var n = this.tryEntries.length - 1; n >= 0; --n) {
                    var o = this.tryEntries[n];
                    if (o.tryLoc <= this.prev && e.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
                        var i = o;
                        break;
                    }
                }
                i && ("break" === t || "continue" === t) && i.tryLoc <= r && r <= i.finallyLoc && (i = null);
                var a = i ? i.completion : {};
                return (
                    (a.type = t),
                    (a.arg = r),
                    i ? ((this.method = "next"), (this.next = i.finallyLoc), f) : this.complete(a)
                );
            },
            complete: function(t, r) {
                if ("throw" === t.type) throw t.arg;
                return (
                    "break" === t.type || "continue" === t.type ?
                    (this.next = t.arg) :
                    "return" === t.type ?
                    ((this.rval = this.arg = t.arg), (this.method = "return"), (this.next = "end")) :
                    "normal" === t.type && r && (this.next = r),
                    f
                );
            },
            finish: function(t) {
                for (var r = this.tryEntries.length - 1; r >= 0; --r) {
                    var e = this.tryEntries[r];
                    if (e.finallyLoc === t) return this.complete(e.completion, e.afterLoc), _(e), f;
                }
            },
            catch: function(t) {
                for (var r = this.tryEntries.length - 1; r >= 0; --r) {
                    var e = this.tryEntries[r];
                    if (e.tryLoc === t) {
                        var n = e.completion;
                        if ("throw" === n.type) {
                            var o = n.arg;
                            _(e);
                        }
                        return o;
                    }
                }
                throw new Error("illegal catch attempt");
            },
            delegateYield: function(t, r, e) {
                return (
                    (this.delegate = {
                        iterator: j(t),
                        resultName: r,
                        nextLoc: e
                    }),
                    "next" === this.method && (this.arg = void 0),
                    f
                );
            }
        }),
        t
    );
}

function _defineProperty(e, r, t) {
    return (
        (r = toPropertyKey(r)) in e ?
        Object.defineProperty(e, r, {
            value: t,
            enumerable: !0,
            configurable: !0,
            writable: !0
        }) :
        (e[r] = t),
        e
    );
}

function _createForOfIteratorHelper(r, e) {
    var t = ("undefined" != typeof Symbol && r[Symbol.iterator]) || r["@@iterator"];
    if (!t) {
        if (Array.isArray(r) || (t = unsupportedIterableToArray(r)) || (e && r && "number" == typeof r.length)) {
            t && (r = t);
            var n = 0,
                o = function() {};
            return {
                s: o,
                n: function() {
                    return n >= r.length ?
                        {
                            done: !0
                        } :
                        {
                            done: !1,
                            value: r[n++]
                        };
                },
                e: function(r) {
                    throw r;
                },
                f: o
            };
        }
        throw new TypeError(
            "Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
        );
    }
    var a,
        u = !0,
        i = !1;
    return {
        s: function() {
            t = t.call(r);
        },
        n: function() {
            var r = t.next();
            return (u = r.done), r;
        },
        e: function(r) {
            (i = !0), (a = r);
        },
        f: function() {
            try {
                u || null == t.return || t.return();
            } finally {
                if (i) throw a;
            }
        }
    };
}

function _slicedToArray(r, e) {
    return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();
}

function _createSuper(t) {
    var e = isNativeReflectConstruct();
    return function() {
        var r,
            o = getPrototypeOf(t);
        if (e) {
            var s = getPrototypeOf(this).constructor;
            r = Reflect.construct(o, arguments, s);
        } else r = o.apply(this, arguments);
        return possibleConstructorReturn(this, r);
    };
}

function _inherits(e, t) {
    if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function");
    (e.prototype = Object.create(t && t.prototype, {
        constructor: {
            value: e,
            writable: !0,
            configurable: !0
        }
    })),
    Object.defineProperty(e, "prototype", {
            writable: !1
        }),
        t && setPrototypeOf(e, t);
}

function _getPrototypeOf(t) {
    return Object.getPrototypeOf(t);
}

function _get() {
    return (
        "undefined" != typeof Reflect && Reflect.get ?
        (_get = Reflect.get.bind()) :
        (_get = function(e, t, r) {
            var o = superPropBase(e, t);
            if (o) {
                var p = Object.getOwnPropertyDescriptor(o, t);
                return p.get ? p.get.call(arguments.length < 3 ? e : r) : p.value;
            }
        }),
        _get.apply(this, arguments)
    );
}

function _classCallCheck(a, l) {
    if (!(a instanceof l)) throw new TypeError("Cannot call a class as a function");
}

function _defineProperties(e, r) {
    for (var t = 0; t < r.length; t++) {
        var o = r[t];
        (o.enumerable = o.enumerable || !1),
        (o.configurable = !0),
        "value" in o && (o.writable = !0),
            Object.defineProperty(e, toPropertyKey(o.key), o);
    }
}

function _createClass(e, r, t) {
    return (
        r && _defineProperties(e.prototype, r),
        t && _defineProperties(e, t),
        Object.defineProperty(e, "prototype", {
            writable: !1
        }),
        e
    );
}
var toPrimitive = _toPrimitive;

function _toPropertyKey(r) {
    var t = toPrimitive(r, "string");
    return "symbol" === typeof t ? t : String(t);
}

function _toPrimitive(r, t) {
    if ("object" !== typeof r || null === r) return r;
    var e = r[Symbol.toPrimitive];
    if (void 0 !== e) {
        var i = e.call(r, t || "default");
        if ("object" !== typeof i) return i;
        throw new TypeError("@@toPrimitive must return a primitive value.");
    }
    return ("string" === t ? String : Number)(r);
}

function asyncGeneratorStep(n, e, r, t, o, a, c) {
    try {
        var i = n[a](c),
            u = i.value;
    } catch (n) {
        return void r(n);
    }
    i.done ? e(u) : Promise.resolve(u).then(t, o);
}

function _asyncToGenerator(n) {
    return function() {
        var e = this,
            r = arguments;
        return new Promise(function(t, o) {
            var a = n.apply(e, r);

            function c(n) {
                asyncGeneratorStep(a, t, o, c, i, "next", n);
            }

            function i(n) {
                asyncGeneratorStep(a, t, o, c, i, "throw", n);
            }
            c(void 0);
        });
    };
}

window._callSuper = function(_this, derived, args) {
    function isNativeReflectConstruct() {
        if (typeof Reflect === "undefined" || !Reflect.construct) return false;
        if (Reflect.construct.sham) return false;
        if (typeof Proxy === "function") return true;
        try {
            return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
        } catch (e) {
            return false;
        }
    }
    derived = _getPrototypeOf(derived);
    return _possibleConstructorReturn(_this, isNativeReflectConstruct() ?
        Reflect.construct(derived, args || [], _getPrototypeOf(_this).constructor) : derived.apply(_this, args));
}